// 工具类文件
import storage from '@system.storage';
import device from '@system.device';

// 权限管理类
export class PermissionManager {
  // 检查并请求权限
  static checkAndRequestPermission(permission) {
    return new Promise(function(resolve, reject) {
      try {
        console.log('检查权限: ' + permission);
        // 这里简化处理，实际应用中需要根据具体权限类型进行处理
        resolve(true);
      } catch (error) {
        console.error('权限检查失败: ' + error);
        reject(error);
      }
    });
  }

  // 显示权限说明弹窗
  static showPermissionDialog(permission, callback) {
    var dialog = {
      title: '权限申请',
      content: '应用需要' + permission + '权限来提供更好的服务，是否允许？',
      buttons: ['取消', '允许']
    };
    
    // 这里应该调用系统的对话框API
    console.log('显示权限对话框:', dialog);
    
    // 模拟用户同意
    if (callback) {
      callback(true);
    }
  }
}

// 存储管理类
export class StorageManager {
  // 保存数据
  static saveData(key, value) {
    return new Promise(function(resolve, reject) {
      try {
        var stringValue = JSON.stringify(value);
        console.log('准备保存数据: ' + key + ', 值:', value);
        console.log('序列化后的值:', stringValue);
        console.log('序列化后的值长度:', stringValue.length);
        
        storage.set({
          key: key,
          value: stringValue,
          success: function() {
            console.log('数据保存成功: ' + key);
            console.log('保存的数据长度:', stringValue.length);
            
            // 延时验证，给存储足够时间完成写入
            setTimeout(function() {
              storage.get({
                key: key,
                success: function(data) {
                  console.log('延时验证：读取成功，值长度:', data.value ? data.value.length : 0);
                  if (data.value && data.value.length > 0) {
                    console.log('延时验证：存储确认成功');
                  } else {
                    console.warn('延时验证：存储可能未完全写入');
                  }
                },
                fail: function(data, code) {
                  console.error('延时验证：读取失败，错误码:', code);
                }
              });
            }, 150); // 150ms延时，给存储足够时间完成写入
            
            // 立即resolve，不等待验证
            resolve();
          },
          fail: function(data, code) {
            console.error('数据保存失败: ' + key + ', 错误码: ' + code);
            reject(new Error('数据保存失败'));
          }
        });
      } catch (error) {
        console.error('存储操作异常: ' + error);
        reject(error);
      }
    });
  }

  // 读取数据
  static getData(key, defaultValue) {
    if (defaultValue === undefined) {
      defaultValue = null;
    }
    
    return new Promise(function(resolve) {
      try {
        storage.get({
          key: key,
          success: function(data) {
            console.log('数据读取成功: ' + key + ', 原始值:', data.value);
            console.log('data.value 类型:', typeof data.value);
            console.log('data.value 是否为null:', data.value === null);
            console.log('data.value 是否为undefined:', data.value === undefined);
            
            // 如果值为空或无效，直接使用默认值
            if (data.value === null || data.value === undefined || data.value === '') {
              console.log('值为空，使用默认值:', defaultValue);
              resolve(defaultValue);
              return;
            }
            
            try {
              var parsedValue = JSON.parse(data.value);
              console.log('解析后的值:', parsedValue);
              console.log('解析后的值类型:', typeof parsedValue);
              
              // 如果解析后的值仍然是null或undefined，使用默认值
              if (parsedValue === null || parsedValue === undefined) {
                console.log('解析后值为空，使用默认值:', defaultValue);
                resolve(defaultValue);
              } else {
                resolve(parsedValue);
              }
            } catch (e) {
              console.log('JSON解析失败，返回原始值:', data.value);
              resolve(data.value);
            }
          },
          fail: function(data, code) {
            console.log('数据读取失败: ' + key + ', 错误码: ' + code + ', 使用默认值:', defaultValue);
            resolve(defaultValue);
          }
        });
      } catch (error) {
        console.error('读取操作异常: ' + error + ', 使用默认值:', defaultValue);
        resolve(defaultValue);
      }
    });
  }

  // 删除数据
  static deleteData(key) {
    return new Promise(function(resolve, reject) {
      try {
        storage.delete({
          key: key,
          success: function() {
            console.log('数据删除成功: ' + key);
            resolve();
          },
          fail: function(data, code) {
            console.error('数据删除失败: ' + key + ', 错误码: ' + code);
            reject(new Error('数据删除失败'));
          }
        });
      } catch (error) {
        console.error('删除操作异常: ' + error);
        reject(error);
      }
    });
  }

  // 清空所有数据
  static clearAll() {
    return new Promise(function(resolve, reject) {
      try {
        storage.clear({
          success: function() {
            console.log('所有数据清空成功');
            resolve();
          },
          fail: function(data, code) {
            console.error('数据清空失败, 错误码: ' + code);
            reject(new Error('数据清空失败'));
          }
        });
      } catch (error) {
        console.error('清空操作异常: ' + error);
        reject(error);
      }
    });
  }
}

// 用户偏好管理类
export class UserPreferenceManager {
  // 定义静态属性
  static get FAVORITES_KEY() {
    return 'user_favorites';
  }
  

  
  static get SETTINGS_KEY() {
    return 'user_settings';
  }
  
  static get PRIVACY_KEY() {
    return 'privacy_agreed';
  }





  // 获取用户设置
  static getSettings() {
    var self = this;
    return StorageManager.getData(this.SETTINGS_KEY, {
      fontSize: 'medium',
      theme: 'classic',
      autoDetectFestival: true
    }).then(function(settings) {
      return settings;
    });
  }

  // 保存用户设置
  static saveSettings(settings) {
    var self = this;
    return StorageManager.saveData(this.SETTINGS_KEY, settings).then(function() {
      console.log('保存用户设置:', settings);
    });
  }

  // 检查是否已同意隐私政策
  static checkPrivacyAgreed() {
    var self = this;
    return StorageManager.getData(this.PRIVACY_KEY, false).then(function(agreed) {
      return agreed;
    });
  }

  // 设置隐私政策同意状态
  static setPrivacyAgreed(agreed) {
    var self = this;
    return StorageManager.saveData(this.PRIVACY_KEY, agreed).then(function() {
      console.log('隐私政策同意状态:', agreed);
    });
  }
}

// 设备信息管理类
export class DeviceManager {
  // 获取设备信息
  static getDeviceInfo() {
    return new Promise(function(resolve) {
      try {
        device.getInfo({
          success: function(data) {
            console.log('获取设备信息成功:', data);
            resolve(data);
          },
          fail: function(data, code) {
            console.error('获取设备信息失败, 错误码: ' + code);
            resolve(null);
          }
        });
      } catch (error) {
        console.error('获取设备信息异常: ' + error);
        resolve(null);
      }
    });
  }

  // 获取屏幕信息
  static getScreenInfo() {
    // 这里应该获取实际的屏幕信息
    return {
      width: 750,
      height: 1334,
      pixelRatio: 2
    };
  }
}

// 日期工具类
export class DateUtils {
  // 获取当前农历日期（简化版）
  static getLunarDate() {
    var now = new Date();
    // 这里应该使用农历转换库
    // 简化处理，返回公历日期
    return {
      year: now.getFullYear(),
      month: now.getMonth() + 1,
      day: now.getDate(),
      isLunar: false
    };
  }

  // 格式化日期
  static formatDate(date, format) {
    if (!format) {
      format = 'YYYY-MM-DD';
    }
    var d = new Date(date);
    var year = d.getFullYear();
    var month = String(d.getMonth() + 1).padStart(2, '0');
    var day = String(d.getDate()).padStart(2, '0');
    
    return format
      .replace('YYYY', year)
      .replace('MM', month)
      .replace('DD', day);
  }

  // 获取节日倒计时
  static getFestivalCountdown(festivalDate) {
    var now = new Date();
    var festival = new Date(festivalDate);
    var diff = festival.getTime() - now.getTime();
    var days = Math.ceil(diff / (1000 * 60 * 60 * 24));
    
    if (days > 0) {
      return days + '天后';
    } else if (days === 0) {
      return '今天';
    } else {
      return '已过';
    }
  }
}

// 文本工具类
export class TextUtils {
  // 截断文本
  static truncate(text, maxLength) {
    if (!maxLength) {
      maxLength = 50;
    }
    if (text.length <= maxLength) {
      return text;
    }
    return text.substring(0, maxLength) + '...';
  }

  // 格式化诗词内容
  static formatPoemContent(content) {
    return content.replace(/。/g, '。\n').replace(/，/g, '，\n');
  }

  // 提取关键词
  static extractKeywords(text) {
    // 简单的关键词提取，实际应用中可以使用更复杂的算法
    var keywords = ['月亮', '思念', '团圆', '春节', '中秋', '端午', '重阳', '元宵'];
    return keywords.filter(function(keyword) {
      return text.includes(keyword);
    });
  }
} 